package com.jddai.service;

import com.jddai.arithmetic.BRBInference;
import com.jddai.arithmetic.PSO_Data;
import com.jddai.dao.DataMapper;
import com.jddai.dao.ModelMapper;
import com.jddai.pojo.CommonRule;
import com.jddai.pojo.DefaultResult;
import com.jddai.pojo.Result;
import com.jddai.pojo.TrainData;
import com.jddai.util.defalutToolMapper;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.io.IOException;
import java.util.*;

@Service
public class BRBService {

    @Autowired
    DataMapper dataMapper;

    @Autowired
    ModelMapper modelMapper;

    @Autowired
    defalutToolMapper toolMapper;

    public Map getData() {
        List<TrainData> allData = dataMapper.getAllData();
        ArrayList<ArrayList<Double>> BTR_data = new ArrayList<>();
        ArrayList<ArrayList<Double>> Stl_data = new ArrayList<>();
        ArrayList<ArrayList<Double>> Data = new ArrayList<>();

        for (int i = 0; i < allData.size(); i++) {
            ArrayList<Double> btr_temp = new ArrayList<>();
            ArrayList<Double> stl_temp = new ArrayList<>();
            ArrayList<Double> data_temp = new ArrayList<>();
            btr_temp.add(allData.get(i).getX1());
            stl_temp.add(allData.get(i).getX1());
            data_temp.add(allData.get(i).getX1());

            btr_temp.add(allData.get(i).getX2());
            stl_temp.add(allData.get(i).getX2());
            data_temp.add(allData.get(i).getX2());

            btr_temp.add(allData.get(i).getX3());
            stl_temp.add(allData.get(i).getX3());
            data_temp.add(allData.get(i).getX3());

            btr_temp.add(allData.get(i).getX4());
            stl_temp.add(allData.get(i).getX4());
            data_temp.add(allData.get(i).getX4());

            btr_temp.add(allData.get(i).getX5());
            stl_temp.add(allData.get(i).getX5());
            data_temp.add(allData.get(i).getX5());

            btr_temp.add(allData.get(i).getX6());
            stl_temp.add(allData.get(i).getX6());
            data_temp.add(allData.get(i).getX6());

            btr_temp.add(allData.get(i).getX7());
            stl_temp.add(allData.get(i).getX7());
            data_temp.add(allData.get(i).getX7());

            btr_temp.add(allData.get(i).getX8());
            stl_temp.add(allData.get(i).getX8());
            data_temp.add(allData.get(i).getX8());

            btr_temp.add(allData.get(i).getX9());
            stl_temp.add(allData.get(i).getX9());
            data_temp.add(allData.get(i).getX9());

            btr_temp.add(allData.get(i).getX10());
            stl_temp.add(allData.get(i).getX10());
            data_temp.add(allData.get(i).getX10());

            btr_temp.add(allData.get(i).getX11());
            stl_temp.add(allData.get(i).getX11());
            data_temp.add(allData.get(i).getX11());

            btr_temp.add(allData.get(i).getX12());
            stl_temp.add(allData.get(i).getX12());
            data_temp.add(allData.get(i).getX12());

            btr_temp.add(allData.get(i).getX13());
            stl_temp.add(allData.get(i).getX13());
            data_temp.add(allData.get(i).getX13());

            btr_temp.add(allData.get(i).getX14());
            stl_temp.add(allData.get(i).getX14());
            data_temp.add(allData.get(i).getX14());

            btr_temp.add(allData.get(i).getX15());
            stl_temp.add(allData.get(i).getX15());
            data_temp.add(allData.get(i).getX15());

            btr_temp.add(allData.get(i).getX16());
            stl_temp.add(allData.get(i).getX16());
            data_temp.add(allData.get(i).getX16());

            btr_temp.add(allData.get(i).getY1());
            stl_temp.add(allData.get(i).getY2());
            BTR_data.add(btr_temp);
            Stl_data.add(stl_temp);
            Data.add(data_temp);
        }
        /*for(int i=0; i<BTR_data.size();i++){
            for(int j=0; j<BTR_data.get(i).size();j++){
                System.out.printf(BTR_data.get(i).get(j)+"\t");
            }
            System.out.println();
        }*/

        Map<String, ArrayList<ArrayList<Double>>> map = new HashMap<>();
        map.put("BTRData", BTR_data);
        map.put("StlData", Stl_data);
        map.put("Data", Data);
        return map;
    }

    public Map getModel() {
        Map<String, ArrayList<ArrayList<Double>>> map = new HashMap<>();
        List<CommonRule> BTR = modelMapper.GetBTRModel();
        List<CommonRule> Stl = modelMapper.GetStlModel();

        ArrayList<ArrayList<Double>> BTRModel = new ArrayList<ArrayList<Double>>();
        ArrayList<ArrayList<Double>> StlModel = new ArrayList<ArrayList<Double>>();

        for (int i = 0; i < BTR.size(); i++) {
            ArrayList<Double> Temp = new ArrayList<>();
            Temp.add(BTR.get(i).getW());
            Temp.add(BTR.get(i).getA1());
            Temp.add(BTR.get(i).getA2());
            Temp.add(BTR.get(i).getA3());
            Temp.add(BTR.get(i).getA4());
            Temp.add(BTR.get(i).getA5());
            Temp.add(BTR.get(i).getA6());
            Temp.add(BTR.get(i).getA7());
            Temp.add(BTR.get(i).getA8());
            Temp.add(BTR.get(i).getA9());
            Temp.add(BTR.get(i).getA10());
            Temp.add(BTR.get(i).getA11());
            Temp.add(BTR.get(i).getA12());
            Temp.add(BTR.get(i).getA13());
            Temp.add(BTR.get(i).getA14());
            Temp.add(BTR.get(i).getA15());
            Temp.add(BTR.get(i).getA16());
            Temp.add(BTR.get(i).getD1());
            Temp.add(BTR.get(i).getD2());
            Temp.add(BTR.get(i).getD3());
            Temp.add(BTR.get(i).getD4());
            Temp.add(BTR.get(i).getD5());
            BTRModel.add(Temp);
        }

        for (int i = 0; i < Stl.size(); i++) {
            ArrayList<Double> Temp = new ArrayList<>();
            Temp.add(Stl.get(i).getW());
            Temp.add(Stl.get(i).getA1());
            Temp.add(Stl.get(i).getA2());
            Temp.add(Stl.get(i).getA3());
            Temp.add(Stl.get(i).getA4());
            Temp.add(Stl.get(i).getA5());
            Temp.add(Stl.get(i).getA6());
            Temp.add(Stl.get(i).getA7());
            Temp.add(Stl.get(i).getA8());
            Temp.add(Stl.get(i).getA9());
            Temp.add(Stl.get(i).getA10());
            Temp.add(Stl.get(i).getA11());
            Temp.add(Stl.get(i).getA12());
            Temp.add(Stl.get(i).getA13());
            Temp.add(Stl.get(i).getA14());
            Temp.add(Stl.get(i).getA15());
            Temp.add(Stl.get(i).getA16());
            Temp.add(Stl.get(i).getD1());
            Temp.add(Stl.get(i).getD2());
            Temp.add(Stl.get(i).getD3());
            Temp.add(Stl.get(i).getD4());
            Temp.add(Stl.get(i).getD5());
            StlModel.add(Temp);
        }

        /*for (int i=0; i<BTRModel.size();i++){
            for(int j=0; j<BTRModel.get(i).size();j++){
                System.out.printf(BTRModel.get(i)+"\t");
            }
            System.out.println();
        }*/

        map.put("BTRModel", BTRModel);
        map.put("StlModel", StlModel);

        return map;
    }

    public Result optimal(String choose, int param) throws IOException {
        Result result = new Result();
        ArrayList<Double> BTRInferenceValues = new ArrayList<>();
        ArrayList<Double> StlInferenceValues = new ArrayList<>();
        ArrayList<ArrayList<Double>> RealDatas = new ArrayList<>();

        ArrayList<Double> BTROptimizalValues = new ArrayList<>();
        ArrayList<Double> StlOptimizalValues = new ArrayList<>();
        ArrayList<ArrayList<Double>> OptimizalDatas = new ArrayList<>();

        ArrayList<ArrayList<Integer>> KeyParam = new ArrayList<>();
        ArrayList<ArrayList<double[]>> Contribution = new ArrayList<>();

        ArrayList<Double> BTR_uscale = new ArrayList<>();
        ArrayList<Double> Stl_uscale = new ArrayList<>();

        Stl_uscale.add(-15.0);
        Stl_uscale.add(-12.0);
        Stl_uscale.add(-9.0);
        Stl_uscale.add(-6.0);
        Stl_uscale.add(-3.0);

        BTR_uscale.add(0.4);
        BTR_uscale.add(1.0);
        BTR_uscale.add(1.6);
        BTR_uscale.add(2.2);
        BTR_uscale.add(2.8);

        Map data = getData();
        ArrayList<ArrayList<Double>> Data = (ArrayList<ArrayList<Double>>) data.get("Data");
        ArrayList<ArrayList<Double>> BTRData = (ArrayList<ArrayList<Double>>) data.get("BTRData");
        ArrayList<ArrayList<Double>> StlData = (ArrayList<ArrayList<Double>>) data.get("StlData");


        for (int i = 0; i < Data.size(); i++) {
            ArrayList<Double> Temp = new ArrayList<>();
            for (int j = 0; j < Data.get(i).size(); j++) {
                Temp.add(Data.get(i).get(j));
            }
            RealDatas.add(Temp);
        }

        Map model = getModel();
        ArrayList<ArrayList<Double>> BTR_Model = (ArrayList<ArrayList<Double>>) model.get("BTRModel");
        ArrayList<ArrayList<Double>> Stl_Model = (ArrayList<ArrayList<Double>>) model.get("StlModel");

        ArrayList<Double> lb = BTR_Model.get(0);
        ArrayList<Double> ub = BTR_Model.get(BTR_Model.size() - 1);

        BRBInference BTR_brb = new BRBInference(BTR_uscale, BTRData, BTR_Model);
        BTR_brb.attr_identify();
        BTR_brb.fuse();
        BTR_brb.contr_w_beta();
        BTR_brb.data_sort();
        BTRInferenceValues = BTR_brb.getInference_Result();

        BRBInference Stl_brb = new BRBInference(Stl_uscale, StlData, Stl_Model);
        Stl_brb.attr_identify();
        Stl_brb.fuse();
        Stl_brb.contr_w_beta();
        Stl_brb.data_sort();
        ArrayList<Double> inference_result = Stl_brb.getInference_Result();
        for (int i = 0; i < inference_result.size(); i++) {
            StlInferenceValues.add(Math.abs(inference_result.get(i)));
        }

        ArrayList<ArrayList<Double>> RealpropValue = new ArrayList<>();
        ArrayList<ArrayList<Double>> OptimizalpropValue = new ArrayList<>();

        ArrayList<ArrayList<double[]>> Pareto = new ArrayList<>();

        for (int arr = 0; arr < Data.size(); arr++) {
            /*System.out.println(arr);*/
            ArrayList<ArrayList<Double>> btr_contribution = BTR_brb.getContribution();
            ArrayList<ArrayList<Double>> stl_contribution = Stl_brb.getContribution();

            ArrayList<ArrayList<Integer>> BTR_attr = BTR_brb.getData_attr();
            ArrayList<ArrayList<Integer>> Stl_attr = Stl_brb.getData_attr();


            ArrayList<Integer> keyParam = choose(choose, param, BTR_brb.getData_attr().get(arr), BTR_brb.getContribution().get(arr),
                    Stl_brb.getData_attr().get(arr), Stl_brb.getContribution().get(arr));

            PSO_Data pso = new PSO_Data(BTR_Model, Stl_Model, Data.get(arr), BTR_uscale, Stl_uscale, keyParam);
            pso.Init();
            pso.Process();
            pso.Topsis();

            double[] topsisFitness = pso.getTopsisFitness();
            if (topsisFitness[0] > BTRInferenceValues.get(arr)
                    || topsisFitness[1] > StlInferenceValues.get(arr)) {
                BTROptimizalValues.add(BTRInferenceValues.get(arr));
                StlOptimizalValues.add(StlInferenceValues.get(arr));

                OptimizalDatas.add(RealDatas.get(arr));
            } else {
                BTROptimizalValues.add(topsisFitness[0]);
                StlOptimizalValues.add(topsisFitness[1]);

                OptimizalDatas.add(pso.getTopsisPop());
            }

            ArrayList<double[]> pareto = pso.getPareto();

            double[] temp3 = new double[2];
            for (int i = 0; i < pareto.size() - 1; i++) {
                for (int j = 0; j < pareto.size() - 1 - i; j++) {
                    if (pareto.get(j)[0] > pareto.get(j + 1)[0]) {
                        temp3 = pareto.get(j);
                        pareto.set(j, pareto.get(j + 1));
                        pareto.set(j + 1, temp3);
                    }
                }
            }

            Pareto.add(pareto);


        /*ArrayList<double[]> paretoSet = pso.getPareto();
        System.out.println("第" + (arr + 1) + "组Pareto前沿:");
        System.out.println(BTRData.get(arr).get(BTRData.get(arr).size() - 1) + "\t" + Math.abs(StlData.get(arr).get(StlData.get(arr).size() - 1)));
        System.out.println(BTR_brb.getInference_Result().get(arr) + "\t" + Math.abs(Stl_brb.getInference_Result().get(arr)));
        for (int j = 0; j < paretoSet.size(); j++) {
            System.out.print(paretoSet.get(j)[0] + "\t" + paretoSet.get(j)[1] + "\n");
        }
        System.out.println();*/

            for (int i = 0; i < keyParam.size(); i++) {
                keyParam.set(i, keyParam.get(i) + 1);//调用过pso函数后，引用值被改变-1了
            }
            KeyParam.add(keyParam);

            ArrayList<double[]> contribution = new ArrayList<>();
            for (int i = 0; i < keyParam.size(); i++) {
                double[] temp = new double[2];
                for (int j = 0; j < BTR_attr.get(arr).size(); j++) {
                    if (BTR_attr.get(arr).get(j).equals(keyParam.get(i))) {
                        temp[0] = btr_contribution.get(arr).get(j);
                    }
                    if (Stl_attr.get(arr).get(j).equals(keyParam.get(i))) {
                        temp[1] = stl_contribution.get(arr).get(j);
                    }
                }
                contribution.add(temp);
            }

            Contribution.add(contribution);

            ArrayList<Double> real_prop = new ArrayList<>();
            ArrayList<Double> optim_prop = new ArrayList<>();
            for (int i = 5; i < 11; i++) {
                real_prop.add((RealDatas.get(arr).get(i) - lb.get(i + 1)) / (ub.get(i + 1) - lb.get(i + 1)) * 100);
                optim_prop.add((OptimizalDatas.get(arr).get(i) - lb.get(i + 1)) / (ub.get(i + 1) - lb.get(i + 1)) * 100);
            }

            RealpropValue.add(real_prop);
            OptimizalpropValue.add(optim_prop);

        }

        result.setBTRInferenceValues(BTRInferenceValues);
        result.setStlInferenceValues(StlInferenceValues);
        result.setRealDatas(RealDatas);

        result.setBTROptimizalValues(BTROptimizalValues);
        result.setStlOptimizalValues(StlOptimizalValues);
        result.setOptimizalDatas(OptimizalDatas);

        result.setKeyParam(KeyParam);
        result.setContribution(Contribution);

        ArrayList<Double> btr_sum_contri = new ArrayList<>();
        ArrayList<Double> stl_sum_contri = new ArrayList<>();
        for(int i=0; i<Contribution.size();i++){
            double sum0 = 0.0;
            double sum1 = 0.0;
            for(int j=0; j<Contribution.get(i).size();j++){
                sum0 += Contribution.get(i).get(j)[0];
                sum1 += Contribution.get(i).get(j)[1];
            }
            btr_sum_contri.add(sum0);
            stl_sum_contri.add(sum1);
        }

        result.setBtr_sum_contri(btr_sum_contri);
        result.setStl_sum_contri(stl_sum_contri);

        /*System.out.println("关键因素个数：");
        for (int i = 0; i < KeyParam.size(); i++) {
            System.out.println(KeyParam.get(i).size());
        }

        System.out.println("btr贡献度总比：");
        for (int i = 0; i < Contribution.size(); i++) {
            double btr_sum = 0.0;
            for (int j = 0; j < Contribution.get(i).size(); j++) {
                btr_sum += Contribution.get(i).get(j)[0];
            }
            System.out.println(btr_sum);
        }

        System.out.println("stl贡献度总比：");
        for (int i = 0; i < Contribution.size(); i++) {
            double stl_sum = 0.0;
            for (int j = 0; j < Contribution.get(i).size(); j++) {
                stl_sum += Contribution.get(i).get(j)[1];
            }
            System.out.println(stl_sum);
        }*/

        result.setRealpropValue(RealpropValue);
        result.setOptimizalpropValue(OptimizalpropValue);

        result.setPareto(Pareto);


        Map<String, List<Double>> inference = new HashMap<>();
        inference.put("btr", BTRInferenceValues);
        inference.put("stl", StlInferenceValues);


        Map<String, Map<String, List<Double>>> defaultData = DefaultData();
        defaultData.put("inference", inference);

        result.setDefaultDataMap(defaultData);

        return result;

    }

    public ArrayList<Integer> choose(String choose, int param, ArrayList<Integer> BTR_attr, ArrayList<Double> BTR_contribution,
                                     ArrayList<Integer> Stl_attr, ArrayList<Double> Stl_contribution) {
        ArrayList<Double> BTR_contribution2 = (ArrayList<Double>) BTR_contribution.clone();
        ArrayList<Double> Stl_contribution2 = (ArrayList<Double>) Stl_contribution.clone();
        ArrayList<Integer> BTR_attr2 = (ArrayList<Integer>) BTR_attr.clone();
        ArrayList<Integer> Stl_attr2 = (ArrayList<Integer>) Stl_attr.clone();

        ArrayList<Integer> keyParam = new ArrayList<>();
        ArrayList<Integer> btr_key = new ArrayList<>();
        ArrayList<Integer> stl_key = new ArrayList<>();

        double btr_sum = 0;
        double stl_sum = 0;

        if (choose.equals("per")) {
            while (btr_sum < param) {
                if (btr_sum < param) {
                    btr_sum += BTR_contribution2.get(0) * 100;
                    btr_key.add(BTR_attr2.get(0));

                    BTR_contribution2.remove(0);
                    BTR_attr2.remove(0);
                }
            }
            while (stl_sum < param) {
                stl_sum += Stl_contribution2.get(0) * 100;
                stl_key.add(Stl_attr2.get(0));

                Stl_contribution2.remove(0);
                Stl_attr2.remove(0);
            }

            for (int i = 0; i < btr_key.size(); i++) {
                keyParam.add(btr_key.get(i));
            }
            for (int i = 0; i < stl_key.size(); i++) {
                boolean flag = true;
                for (int j = 0; j < keyParam.size(); j++) {
                    if (stl_key.get(i).equals(keyParam.get(j))) flag = false;
                }
                if (flag) keyParam.add(stl_key.get(i));
            }

            btr_sum = 0;
            stl_sum = 0;

            for (int i = 0; i < keyParam.size(); i++) {
                int btr_index = 0;
                int stl_index = 0;
                for (int j = 0; j < BTR_attr.size(); j++) {
                    if (BTR_attr.get(j).equals(keyParam.get(i))) {
                        btr_index = j;
                    }
                }
                for (int j = 0; j < Stl_attr.size(); j++) {
                    if (Stl_attr.get(j).equals(keyParam.get(i))) {
                        stl_index = j;
                    }
                }
                btr_sum += BTR_contribution.get(btr_index) * 100;
                stl_sum += Stl_contribution.get(stl_index) * 100;
            }

            for (int i = keyParam.size() - 1; i >= 0; i--) {
                int btr_index = 0;
                int stl_index = 0;
                for (int j = 0; j < BTR_attr.size(); j++) {
                    if (BTR_attr.get(j).equals(keyParam.get(i))) {
                        btr_index = j;
                    }
                }
                for (int j = 0; j < Stl_attr.size(); j++) {
                    if (Stl_attr.get(j).equals(keyParam.get(i))) {
                        stl_index = j;
                    }
                }

                if ((btr_sum - BTR_contribution.get(btr_index) * 100) > param && (stl_sum - Stl_contribution.get(stl_index) * 100) > param) {
                    keyParam.remove(i);
                    btr_sum -= BTR_contribution.get(btr_index) * 100;
                    stl_sum -= Stl_contribution.get(stl_index) * 100;
                }

            }

        } else {
            if (param == 1) {
                if (BTR_contribution2.get(0) > Stl_contribution2.get(0)) {
                    keyParam.add(BTR_attr2.get(0));
                    return keyParam;
                } else {
                    keyParam.add(Stl_attr2.get(0));
                    return keyParam;
                }
            } else {
                if (BTR_attr2.get(0).equals(Stl_attr2.get(0))) {
                    keyParam.add(BTR_attr2.get(0));
                    BTR_contribution2.set(0, 0.0);
                    Stl_contribution2.set(0, 0.0);
                } else {
                    keyParam.add(BTR_attr2.get(0));
                    keyParam.add(Stl_attr2.get(0));
                    BTR_contribution2.set(0, 0.0);
                    Stl_contribution2.set(0, 0.0);

                    for (int i = 0; i < Stl_contribution2.size(); i++) {
                        if (Stl_attr2.get(i).equals(BTR_attr2.get(0))) {
                            Stl_contribution2.set(i, 0.0);
                        }
                    }

                    for (int i = 0; i < BTR_contribution2.size(); i++) {
                        if (BTR_attr2.get(i).equals(Stl_attr2.get(0))) {
                            BTR_contribution2.set(i, 0.0);
                        }
                    }
                }


                while (keyParam.size() < param) {
                    double btr_max = 0.0;
                    int btr_index = 0;
                    double stl_max = 0.0;
                    int stl_index = 0;
                    for (int i = 0; i < BTR_contribution2.size(); i++) {
                        if (btr_max < BTR_contribution2.get(i)) {
                            btr_max = BTR_contribution2.get(i);
                            btr_index = i;
                        }

                        if (stl_max < Stl_contribution2.get(i)) {
                            stl_max = Stl_contribution2.get(i);
                            stl_index = i;
                        }
                    }

                    if (btr_max > stl_max) {
                        keyParam.add(BTR_attr2.get(btr_index));
                        BTR_contribution2.set(btr_index, 0.0);
                        for (int i = 0; i < Stl_contribution2.size(); i++) {
                            if (Stl_attr2.get(i).equals(BTR_attr2.get(btr_index))) {
                                Stl_contribution2.set(i, 0.0);
                            }
                        }
                    } else {
                        keyParam.add(Stl_attr2.get(stl_index));
                        Stl_contribution2.set(stl_index, 0.0);
                        for (int i = 0; i < BTR_contribution2.size(); i++) {
                            if (BTR_attr2.get(i).equals(Stl_attr2.get(stl_index))) {
                                BTR_contribution2.set(i, 0.0);
                            }
                        }
                    }
                }
            }
        }

        return keyParam;
    }


    public Map<String, Map<String, List<Double>>> DefaultData() {
        Map<String, Map<String, List<Double>>> defaultDataMap = new HashMap<>();

        List<DefaultResult> btrDefaultData = toolMapper.getBTRDefaultData();
        List<DefaultResult> stlDefaultData = toolMapper.getStlDefaultData();

        List<Double> btr_per50 = new ArrayList<>();
        List<Double> btr_per60 = new ArrayList<>();
        List<Double> btr_per70 = new ArrayList<>();
        List<Double> btr_per80 = new ArrayList<>();
        List<Double> btr_per90 = new ArrayList<>();
        List<Double> btr_per100 = new ArrayList<>();
        List<Double> btr_num1 = new ArrayList<>();
        List<Double> btr_num2 = new ArrayList<>();
        List<Double> btr_num3 = new ArrayList<>();
        List<Double> btr_num4 = new ArrayList<>();
        List<Double> btr_num5 = new ArrayList<>();
        List<Double> btr_num6 = new ArrayList<>();

        Map<String, List<Double>> btrDefault = new HashMap<>();
        for (int i = 0; i < btrDefaultData.size(); i++) {
            btr_per50.add(btrDefaultData.get(i).getPer50());
            btr_per60.add(btrDefaultData.get(i).getPer60());
            btr_per70.add(btrDefaultData.get(i).getPer70());
            btr_per80.add(btrDefaultData.get(i).getPer80());
            btr_per90.add(btrDefaultData.get(i).getPer90());
            btr_per100.add(btrDefaultData.get(i).getPer100());
            btr_num1.add(btrDefaultData.get(i).getNum1());
            btr_num2.add(btrDefaultData.get(i).getNum2());
            btr_num3.add(btrDefaultData.get(i).getNum3());
            btr_num4.add(btrDefaultData.get(i).getNum4());
            btr_num5.add(btrDefaultData.get(i).getNum5());
            btr_num6.add(btrDefaultData.get(i).getNum6());
        }

        btrDefault.put("per50", btr_per50);
        btrDefault.put("per60", btr_per60);
        btrDefault.put("per70", btr_per70);
        btrDefault.put("per80", btr_per80);
        btrDefault.put("per90", btr_per90);
        btrDefault.put("per100", btr_per100);

        btrDefault.put("num1", btr_num1);
        btrDefault.put("num2", btr_num2);
        btrDefault.put("num3", btr_num3);
        btrDefault.put("num4", btr_num4);
        btrDefault.put("num5", btr_num5);
        btrDefault.put("num6", btr_num6);

        List<Double> stl_per50 = new ArrayList<>();
        List<Double> stl_per60 = new ArrayList<>();
        List<Double> stl_per70 = new ArrayList<>();
        List<Double> stl_per80 = new ArrayList<>();
        List<Double> stl_per90 = new ArrayList<>();
        List<Double> stl_per100 = new ArrayList<>();
        List<Double> stl_num1 = new ArrayList<>();
        List<Double> stl_num2 = new ArrayList<>();
        List<Double> stl_num3 = new ArrayList<>();
        List<Double> stl_num4 = new ArrayList<>();
        List<Double> stl_num5 = new ArrayList<>();
        List<Double> stl_num6 = new ArrayList<>();

        Map<String, List<Double>> stlDefault = new HashMap<>();
        for (int i = 0; i < stlDefaultData.size(); i++) {
            stl_per50.add(stlDefaultData.get(i).getPer50());
            stl_per60.add(stlDefaultData.get(i).getPer60());
            stl_per70.add(stlDefaultData.get(i).getPer70());
            stl_per80.add(stlDefaultData.get(i).getPer80());
            stl_per90.add(stlDefaultData.get(i).getPer90());
            stl_per100.add(stlDefaultData.get(i).getPer100());

            stl_num1.add(stlDefaultData.get(i).getNum1());
            stl_num2.add(stlDefaultData.get(i).getNum2());
            stl_num3.add(stlDefaultData.get(i).getNum3());
            stl_num4.add(stlDefaultData.get(i).getNum4());
            stl_num5.add(stlDefaultData.get(i).getNum5());
            stl_num6.add(stlDefaultData.get(i).getNum6());
        }

        stlDefault.put("per50", stl_per50);
        stlDefault.put("per60", stl_per60);
        stlDefault.put("per70", stl_per70);
        stlDefault.put("per80", stl_per80);
        stlDefault.put("per90", stl_per90);
        stlDefault.put("per100", stl_per100);

        stlDefault.put("num1", stl_num1);
        stlDefault.put("num2", stl_num2);
        stlDefault.put("num3", stl_num3);
        stlDefault.put("num4", stl_num4);
        stlDefault.put("num5", stl_num5);
        stlDefault.put("num6", stl_num6);

        defaultDataMap.put("btrDefault", btrDefault);
        defaultDataMap.put("stlDefault", stlDefault);

        return defaultDataMap;
    }
}
